home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1998 November / Freeware November 1998.img / dist / fw_GGxli.idb / usr / freeware / src / xli-1.16 / rotate.c.z / rotate.c
C/C++ Source or Header  |  1997-09-09  |  6KB  |  190 lines
  1. /* #ident    "@(#)x11:contrib/clients/xloadimage/rotate.c 1.8 93/07/23 Labtam" */
  2. /* rotate.c
  3.  *
  4.  * rotate an image
  5.  *
  6.  * Contributed by Tom Tatlow (tatlow@dash.enet.dec.com)
  7.  */
  8.  
  9. #include "copyright.h"
  10. #include "xli.h"
  11.  
  12. /* rotate_bitmap()
  13.  * converts an old bitmap bit position into a new one
  14.  */
  15. void rotate_bitmap(num, pos, width, height, new_num, new_pos)
  16. int      num;                /* Source byte number       */
  17. int      pos;                /* Source bit position      */
  18. int    width;                /* Width of source bitmap   */
  19. int   height;                /* Height of source bitmap  */
  20. int *new_num;                /* Destination byte number  */
  21. int *new_pos;                /* Destination bit position */
  22. {
  23.   int   slen;                /* Length of source line      */
  24.   int   dlen;                /* Length of destination line */
  25.   int sx, sy;
  26.   int dx, dy;
  27.  
  28.   slen = (width / 8) + (width % 8 ? 1 : 0);
  29.   dlen = (height / 8) + (height % 8 ? 1 : 0);
  30.   sy = num / slen;
  31.   sx = ((num - (sy * slen)) * 8) + pos;
  32.   dx = (height - sy) - 1;
  33.   dy = sx;
  34.   *new_num = (dx / 8) + (dy * dlen);
  35.   *new_pos = dx % 8;
  36. }
  37.  
  38. /* rotate()
  39.  * rotates an image
  40.  */
  41. Image *rotate(iimage, rotate, verbose)
  42. Image *iimage;                /* Image to rotate             */
  43. int    rotate;                /* Number of degrees to rotate */
  44. { 
  45.   int          rot;            /* Actual rotation             */
  46.   Image    *simage;            /* Source image                */
  47.   Image    *dimage;            /* Destination image           */
  48.   byte         *sp;            /* Pointer to source data      */
  49.   byte         *dp;            /* Pointer to destination data */
  50.   int     slinelen;            /* Length of source line       */
  51.   int     dlinelen;            /* Length of destination line  */
  52.   int       bit[8];            /* Array of hex values         */
  53.   int         x, y;
  54.   int         i, b;
  55.   int   newx, newy;
  56.   int   newi, newb;
  57.   byte      **yptr;
  58.  
  59.   bit[0] = 128;
  60.   bit[1] =  64;
  61.   bit[2] =  32;
  62.   bit[3] =  16;
  63.   bit[4] =   8;
  64.   bit[5] =   4;
  65.   bit[6] =   2;
  66.   bit[7] =   1;
  67.  
  68.   CURRFUNC("rotate");
  69.  
  70.   if (verbose)
  71.     { printf("  Rotating image by %d degrees...", rotate);
  72.       fflush(stdout);
  73.     }
  74.  
  75.   simage = iimage;
  76.   for(rot=0;rot < rotate; rot +=90) {
  77.     switch (simage->type) {
  78.     case IBITMAP:
  79.       dimage= newBitImage(simage->height, simage->width);
  80.       for (x= 0; x < simage->rgb.used; x++) {
  81.     *(dimage->rgb.red + x)= *(simage->rgb.red + x);
  82.     *(dimage->rgb.green + x)= *(simage->rgb.green + x);
  83.     *(dimage->rgb.blue + x)= *(simage->rgb.blue + x);
  84.       }
  85.       slinelen= (simage->width / 8) + (simage->width % 8 ? 1 : 0);
  86.       sp = simage->data;
  87.       dp = dimage->data;
  88.       for (i = 0; i < (slinelen * simage->height); i++)
  89.     for (b = 0; b < 8; b++)
  90.       if (sp[i] & bit[b])
  91.         { rotate_bitmap(i, b, simage->width, simage->height, &newi, &newb);
  92.           dp[newi] |= bit[newb];
  93.         }
  94.       break;
  95.       
  96.     case IRGB:
  97.       dimage= newRGBImage(simage->height, simage->width, simage->depth);
  98.       for (x= 0; x < simage->rgb.used; x++) {
  99.     *(dimage->rgb.red + x)= *(simage->rgb.red + x);
  100.     *(dimage->rgb.green + x)= *(simage->rgb.green + x);
  101.     *(dimage->rgb.blue + x)= *(simage->rgb.blue + x);
  102.       }
  103.       dimage->rgb.used= simage->rgb.used;
  104.  
  105.       /* build array of y axis ptrs into destination image
  106.        */
  107.  
  108.       yptr= (byte **)lmalloc(simage->width * sizeof(char *));
  109.       dlinelen= simage->height * dimage->pixlen;
  110.       for (y= 0; y < simage->width; y++)
  111.     yptr[y]= dimage->data + (y * dlinelen);
  112.  
  113.       /* rotate
  114.        */
  115.  
  116.       sp= simage->data;
  117.       if(simage->pixlen == 1 && dimage->pixlen == 1)    /* most common */
  118.         for (y = 0; y < simage->height; y++)
  119.           for (x = 0; x < simage->width; x++) {
  120.             register unsigned long temp;
  121.             temp = memToVal(sp, 1);
  122.             valToMem(temp, yptr[x] + (simage->height - y - 1),1);
  123.             sp += 1;
  124.           }
  125.       else    /* less common */
  126.         for (y = 0; y < simage->height; y++)
  127.           for (x = 0; x < simage->width; x++) {
  128.             register unsigned long temp;
  129.             temp = memToVal(sp, simage->pixlen);
  130.             valToMem(temp,
  131.                  yptr[x] + ((simage->height - y - 1) * dimage->pixlen),
  132.                  dimage->pixlen);
  133.             sp += simage->pixlen;
  134.           }
  135.       lfree(yptr);
  136.       break;
  137.  
  138.     case ITRUE:
  139.       if (TRUEP(simage))
  140.     dimage= newTrueImage(simage->height, simage->width);
  141.  
  142.       /* build array of y axis ptrs into destination image
  143.        */
  144.  
  145.       yptr= (byte **)lmalloc(simage->width * sizeof(char *));
  146.       dlinelen= simage->height * dimage->pixlen;
  147.       for (y= 0; y < simage->width; y++)
  148.     yptr[y]= dimage->data + (y * dlinelen);
  149.  
  150.       /* rotate
  151.        */
  152.  
  153.       sp= simage->data;
  154.       if(simage->pixlen == 3 && dimage->pixlen == 3)    /* most common */
  155.         for (y = 0; y < simage->height; y++)
  156.           for (x = 0; x < simage->width; x++) {
  157.             register unsigned long temp;
  158.             temp = memToVal(sp, 3);
  159.             valToMem(temp, yptr[x] + ((simage->height - y - 1) * 3),3);
  160.             sp += 3;
  161.           }
  162.       else    /* less common */
  163.         for (y = 0; y < simage->height; y++)
  164.           for (x = 0; x < simage->width; x++) {
  165.             register unsigned long temp;
  166.             temp = memToVal(sp, simage->pixlen);
  167.             valToMem(temp,
  168.                  yptr[x] + ((simage->height - y - 1) * dimage->pixlen),
  169.                  dimage->pixlen);
  170.             sp += simage->pixlen;
  171.           }
  172.       lfree(yptr);
  173.       break;
  174.     default:
  175.       printf("rotate: Unsupported image type\n");
  176.       exit(1);
  177.     }
  178.   if(simage != iimage)
  179.     freeImage(simage);
  180.   simage = dimage;
  181.   }
  182.   dimage->title= (char *)lmalloc(strlen(iimage->title) + 40);
  183.   sprintf(dimage->title, "%s (rotated by %d degrees)", iimage->title, rot);
  184.   dimage->gamma= iimage->gamma;
  185.   if (verbose)
  186.     printf("done\n");
  187.   return(dimage);
  188. }
  189.  
  190.